home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / c_edit.arc / ED10.C < prev    next >
C/C++ Source or Header  |  1991-09-08  |  7KB  |  410 lines
  1. /* ED10.C */
  2.  
  3. #include "b:ed0.c"
  4. #include "b:ed1.ccc"
  5. int bufcflag;
  6. char *bufbot;
  7. char *bufp;
  8. char *bufpmax;
  9. char *bufend;
  10. int bufline;
  11. int bufmaxln;
  12. bufnew()
  13. {
  14.     bufp=bufpmax=bufbot=_memory()+1;
  15.     bufend=sysend();
  16.     bufline=1;
  17.     bufmaxln=0;
  18.     *(bufp-1)=CR;
  19.     bufcflag=NO;
  20. }
  21. bufln()
  22. {
  23.     return(bufline);
  24. }
  25. bufchng()
  26. {
  27.     return(bufcflag);
  28. }
  29. bufsaved()
  30. {
  31.     bufcflag=NO;
  32. }
  33. buffree()
  34. {
  35.     return(bufend-bufp);
  36. }
  37. bufgo(line) int line;
  38. {
  39.     line=min(bufmaxln+1,line);
  40.     line=max(1,line);
  41.     if (line==bufline) {
  42.         return(OK);
  43.     }
  44.     while (line<bufline) {
  45.         if (bufup()==ERR) {
  46.             return(ERR);
  47.         }
  48.     }
  49.     while (line>bufline) {
  50.         if (bufdn()==ERR) {
  51.             return(ERR);
  52.         }
  53.     }
  54.     return(OK);
  55. }
  56. bufup()
  57. {
  58. char *oldbufp;
  59.     oldbufp=bufp;
  60.     if (bufattop()) {
  61.         return(OK);
  62.     }
  63.     if (*--bufp!=CR) {
  64.         syserr("bufup:    missing CR");
  65.         bufp=oldbufp;
  66.         sysabort();
  67.         return(ERR);
  68.     }
  69.     while (*--bufp!=CR) {
  70.         ;
  71.     }
  72.     bufp++;
  73.     if (bufp<bufbot) {
  74.         syserr ("bufup: bufp underflow");
  75.         bufp=oldbufp;
  76.         sysabort();
  77.         return(ERR);
  78.     }
  79.     bufline--;
  80.     return(OK);
  81. }
  82. bufdn()
  83. {
  84. char *oldbufp;
  85.     oldbufp=bufp;
  86.     if (bufatbot()) {
  87.         return(OK);
  88.     }
  89.     while (*bufp++!=CR) {
  90.         ;
  91.     }
  92.     if (bufp>bufpmax) {
  93.         syserr("bufdn: bufp overflow");
  94.         bufp=oldbufp;
  95.         sysabort();
  96.         return(ERR);
  97.     }
  98.     bufline++;
  99.     return(OK);
  100. }
  101. bufins(p,n) char *p; int n;
  102. {            
  103. int k;        
  104.     if(bufext(n+1)==ERR) {
  105.         return(ERR);
  106.     }
  107.     k=0;
  108.     while (k<n) {
  109.         *(bufp+k)= *(p+k);
  110.         k++;
  111.     }
  112.     *(bufp+k)=CR;
  113.     bufmaxln++;
  114.     if ((n==0)&(bufnrbot())) {
  115.         ;
  116.     }
  117.     else {
  118.         bufcflag=YES;
  119.     }
  120.     return(OK);
  121. }
  122. buf1ins(p,n) char *p; int n;     /* altered: a full buffer does not truncate */
  123. {                /*   line, but issues warning and returns   */
  124. int k, x;            /*   ERR - allows editing of large files    */
  125.     x = 0;            /*   in pieces */
  126.     if(bufstrch(n+1)==ERR) {
  127.         x = 1;
  128.     }
  129.     k=0;
  130.     while (k<n) {
  131.         *(bufp+k)= *(p+k);
  132.         k++;
  133.     }
  134.     *(bufp+k)=CR;
  135.     bufmaxln++;
  136.     if ((n==0)&(bufnrbot())) {
  137.         ;
  138.     }
  139.     else {
  140.         bufcflag=YES;
  141.     }
  142.     if (x == 0) {
  143.         return(OK);
  144.     }
  145.     else {
  146.         sysabort();
  147.         return(ERR);
  148.     }
  149. }
  150. bufdel()
  151. {
  152.     return(bufndel(1));
  153. }
  154. bufndel(n) int n;
  155. {
  156. int oldline;
  157. int k;
  158. char *oldbufp;
  159.     oldline=bufline;
  160.     oldbufp=bufp;
  161.     k=0;
  162.     while ((n--)>0) {
  163.         if (bufatbot()) {
  164.             break;
  165.         }
  166.         if (bufdn()==ERR) {
  167.             bufline=oldline;
  168.             bufp=oldbufp;
  169.             return(ERR);
  170.         }
  171.         k++;
  172.     }
  173.     bufupmov(bufp,bufpmax-1,bufp-oldbufp);
  174.     bufpmax=bufpmax-(bufp-oldbufp);
  175.     bufp=oldbufp;
  176.     bufline=oldline;
  177.     bufmaxln=bufmaxln-k;
  178.     bufcflag=YES;
  179.     return(OK);
  180. }
  181. bufrepl(p,n) char *p; int n;
  182. {
  183. int oldlen, k;
  184. char *nextp;
  185.     if (bufatbot()) {
  186.         return(bufins(p,n));
  187.     }
  188.     if (bufdn()==ERR) {
  189.         return(ERR);
  190.     }
  191.     nextp=bufp;
  192.     if (bufup()==ERR) {
  193.         return(ERR);
  194.     }
  195.     n=n+1;
  196.     oldlen=nextp-bufp;
  197.     if (oldlen<n) {
  198.         if (bufext(n-oldlen)==ERR) {
  199.             return(ERR);
  200.         }
  201.        /*    bufpmax=bufpmax+n-oldlen;   Note: Error in original listing */
  202.     }
  203.     else if (oldlen>n) {
  204.         bufupmov(nextp,bufpmax-1,oldlen-n);
  205.         bufpmax=bufpmax-(oldlen-n);
  206.     }
  207.     k=0;
  208.     while (k<(n-1)) {
  209.         bufp[k]=p[k];
  210.         k++;
  211.     }
  212.     bufp[k]=CR;
  213.     bufcflag=YES;
  214.     return(OK);
  215. }
  216. bufgetln(p,n) char *p; int n;
  217. {
  218. int k;
  219.     if (bufatbot()) {
  220.         return(0);
  221.     }
  222.     k=0;
  223.     while (k<n) {
  224.         if (*(bufp+k)==CR) {
  225.             return(k);
  226.         }
  227.         *(p+k)= *(bufp+k);
  228.         k++;
  229.     }
  230.     while (*(bufp+k)!=CR) {
  231.         k++;
  232.     }
  233.     return(k);
  234. }
  235. bufdnmov(from,to,length) char *from, *to; int length;
  236. {
  237.     sysdnmov(to-from+1,from+length,from);  /*altered for _move */
  238. }
  239. bufupmov(from,to,length) char *from, *to; int length;
  240. {
  241.     sysupmov(to-from+1,from-length,from);
  242. }
  243. bufatbot()
  244. {
  245.     return(bufline>bufmaxln);
  246. }
  247. bufnrbot()
  248. {
  249.     return(bufline>=bufmaxln);
  250. }
  251. bufattop()
  252. {
  253.     return(bufline==1);
  254. }
  255. bufout(topline,topy,nlines) int topline, topy, nlines;
  256. {
  257. int l,p;
  258.     l=bufline;
  259.     p=bufp;
  260.     while ((nlines--)>0) {
  261.         outxy(0,topy++);
  262.         buflnout(topline++);
  263.     }
  264.     bufline=l;
  265.     bufp=p;
  266. }
  267. buflnout(line) int line;
  268. {
  269. int c;
  270.     if (bufgo(line)==ERR) {
  271.         diskerr(" line deleted");
  272.         outdeol();
  273.         sysabort();
  274.         return;
  275.     }
  276.     if (bufatbot()) {
  277.         outdeol();
  278.     }
  279.     else {
  280.         c=fmtsout(bufp,0);        /* c= added */
  281.         if (c<SCRNW1) {          /* now allows full screen */
  282.         outdeol();
  283.         }
  284.     }
  285. }
  286. bufext(length) int length;
  287. {
  288.     if ((bufpmax+length)>=bufend) {
  289.         error("main buffer is full");
  290.         sysabort();
  291.         return(ERR);
  292.     }
  293.     bufdnmov(bufp,bufpmax-1,length);
  294.     bufpmax=bufpmax+length;
  295.     return(OK);
  296. }
  297. /* bufstrch is bufext modifed to allow entering beyond buffer with warning */
  298. bufstrch(length) int length;
  299. {
  300.     if ((bufpmax+length)>=bufend) {
  301.         bufdnmov(bufp,bufpmax-1,length);
  302.         bufpmax=bufpmax+length;
  303.         message("Caution: main buffer is full");
  304.         sysabort();
  305.         return(ERR);
  306.     }
  307.     bufdnmov(bufp,bufpmax-1,length);
  308.     bufpmax=bufpmax+length;
  309.     return(OK);
  310. }
  311. buflength(first,n) int first, n;   /* new: returns length of n lines from  */
  312. {                   /* first line specified */
  313. char *start;
  314. int i,len,line;
  315.     if (n<=0) {
  316.         len=0;
  317.         return(len);
  318.     }
  319.     if (bufgo(first)==ERR) {
  320.         len=0;
  321.         return(len);
  322.     }
  323.     start=bufp;
  324.     i=1;
  325.     line = first;
  326.     while (i++<=n) {
  327.         if (bufgo(++line)==ERR) {
  328.             len=0;
  329.             return(len);
  330.         }
  331.     }
  332.     len=bufp-start;
  333.     return(len);
  334. }
  335. bufcopy(from,to,n) int from,to,n;    /* new: copies "n" lines from "from"  */
  336. {                    /*    to "to" */
  337. int length;
  338. char *source,*dest;
  339.     if (from==to){
  340.         return;
  341.     }
  342.     if ((length=buflength(from,n))==0){
  343.         return;
  344.     }
  345.     if (bufgo(from)==ERR){
  346.         return;
  347.     }
  348.     source=bufp;
  349.     if (bufgo(to)==ERR){
  350.         return;
  351.     }
  352.     dest=bufp;
  353.     if ((bufpmax+length)>=bufend) {
  354.         error("insufficient room in buffer for copy or move");
  355.         sysabort();
  356.         return;
  357.     }
  358.     if (bufext(length)==ERR){
  359.         return;
  360.     }
  361.     bufgo(1);
  362.     bufmaxln=bufmaxln+n;
  363.     if (from<to) {
  364.         sysupmov(length,dest,source);
  365.     }
  366.     else {
  367.         sysupmov(length,dest,source+length);
  368.     }
  369. }
  370. buftopick(dest,start_line,nlines) char *dest; int start_line,nlines;
  371.     /* move nlines from main- to pick-buffer */
  372. {
  373. int length;
  374. char *source;
  375.     if (nlines==0) {
  376.         return(OK);
  377.     }
  378.     if ((length=buflength(start_line,nlines))==0){
  379.         return(OK);
  380.     }
  381.     if (bufgo(start_line)==ERR){
  382.         return(ERR);
  383.     }
  384.     source=bufp;
  385.     sysupmov(length,dest,source);
  386.     return(OK);
  387. }
  388. picktobuf(source,length,lines) char *source; int length,lines;
  389.     /* move indicated pick buffer to main buffer */
  390. {
  391. char *dest;
  392.     if (length==0)
  393.     {
  394.         return(OK);
  395.     }
  396.     dest=bufp;
  397.     if ((bufpmax+length)>=bufend){
  398.         error("insufficient room in buffer for put");
  399.         sysabort();
  400.         return(ERR);
  401.     }
  402.     if (bufext(length)==ERR){
  403.         return(ERR);
  404.     }
  405.     bufgo(1);
  406.     bufmaxln=bufmaxln+lines;
  407.     sysdnmov(length,dest,source);
  408.     return(OK);
  409. }
  410.